﻿<html DIR="LTR" xmlns:tool="http://www.microsoft.com/tooltip" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ddue="http://ddue.schemas.microsoft.com/authoring/2003/5" xmlns:MSHelp="http://msdn.microsoft.com/mshelp">
  <head>
    <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8" />
    <META NAME="save" CONTENT="history" />
    <title>Usando tipos de dados avançados</title>
    
    <link rel="stylesheet" type="text/css" href="../local/Classic.css">
      
    </link>
    
    <script src="../local/script.js">
      
    </script><script src="../local/script_main.js">&amp;nbsp;</script>
  </head>
  <body>
    <!--Topic built:04/01/2010 05:03:30-->

    
    
    
    
    
    
    
    
    
    <div id="header">
      <table width="100%" id="topTable"><tr>
          <td align="left">
            <span id="headerBold">Usando tipos de dados avançados</span>
          </td>
          <td align="right">
            
          </td>
        </tr></table>
      
      
      
    </div>
    <div id="mainSection">
      
        
        
    <font color="DarkGray">
      
    </font>
    <p />
    
    <p />
  
        <div id="introductionSection" class="section">
    <p>O Microsoft SQL Server JDBC Driver usa os tipos de dados avançados JDBC para converter os tipos de dados do SQL Server para um formato que pode ser entendido pela linguagem de programação Java. </p>
    <p>A tabela a seguir lista os mapeamentos padrão entre o SQL Server avançado, o JDBC e os tipos de dados da linguagem de programação Java.</p>
    <table width="100%" cellspacing="0" cellpadding="0" border="1" style="background-color: #CCCCCC;"><tr>
          <th colspan="">
            Tipos de SQL Server
          </th>
          <th colspan="">
            Tipos JDBC (java.sql.Types)
          </th>
          <th colspan="">
            Tipos da linguagem Java
          </th>
        </tr><tr>
        <td colspan="">
          <p>varbinary(max)</p>
          <p>imagem</p>
        </td>
        <td colspan="">
          <p>LONGVARBINARY</p>
        </td>
        <td colspan="">
          <p>byte[] (default), Blob, InputStream, String</p>
        </td>
      </tr><tr>
        <td colspan="">
          <p>text</p>
          <p>varchar(max)</p>
        </td>
        <td colspan="">
          <p>LONGVARCHAR</p>
        </td>
        <td colspan="">
          <p>String (default), Clob, InputStream</p>
        </td>
      </tr><tr>
        <td colspan="">
          <p>ntext</p>
          <p>nvarchar(max)</p>
        </td>
        <td colspan="">
          <p>LONGVARCHAR</p>
          <p>LONGNVARCHAR (Java SE 6.0)</p>
        </td>
        <td colspan="">
          <p>String (default), Clob, NClob (Java SE 6.0)</p>
        </td>
      </tr><tr>
        <td colspan="">
          <p>xml</p>
        </td>
        <td colspan="">
          <p>LONGVARCHAR</p>
          <p>SQLXML (Java SE 6.0)</p>
        </td>
        <td colspan="">
          <p>String (default), InputStream, Clob, byte[],Blob, SQLXML (Java SE 6.0)</p>
        </td>
      </tr><tr>
        <td colspan="">
          <p>udt</p>
        </td>
        <td colspan="">
          <p>VARBINARY</p>
        </td>
        <td colspan="">
          <p>String (default), byte[], InputStream</p>
        </td>
      </tr></table>
    <p>As seguintes seções fornecem exemplos de como é possível usar o driver JDBC e os tipos de dados avançados.</p>
  </div><h1 class="heading">Tipos de dados BLOB e CLOB e NCLOB</h1><div id="sectionSection0" class="section"><content xmlns="http://ddue.schemas.microsoft.com/authoring/2003/5">
      <p xmlns="">O JDBC Driver implementa todos os métodos das interfaces java.sql.Blob, java.sql.Clob e java.sql.NClob. </p>
      <div style="margin: .5em 1.5em .5em 1.5em" xmlns=""><b>Observação: </b>
        Os valores CLOB podem ser usados com tipos de dados de valor grande do SQL Server 2005 (ou posterior). Especificamente, tipos CLOB podem ser usados com os tipos de dados <b>varchar(max)</b> e <b>nvarchar(max)</b>, tipos BLOB podem ser usados com tipos de dados <b>varbinary(max)</b> e <b>image</b>, e tipos NCLOB podem ser usados com <b>ntext</b> e <b>nvarchar(max)</b>.<p />
      </div>
    </content></div><h1 class="heading">Tipos de dados de valor grande</h1><div id="sectionSection1" class="section"><content xmlns="http://ddue.schemas.microsoft.com/authoring/2003/5">
      <p xmlns="">Em versões anteriores do SQL Server, trabalhar com tipos de dados de valor grande exigia procedimentos especiais. Os tipos de dados de valor grande são aqueles que excedem o tamanho de linha máximo de 8 KB. O SQL Server introduz um especificador max para tipos de dados <b>varchar</b>, <b>nvarchar</b> e <b>varbinary</b> a fim de permitir o armazenamento de valores de até 2^31 bytes. Colunas de tabela e variáveis Transact-SQL podem especificar tipos de dados <b>varchar(max)</b>, <b>nvarchar(max)</b> ou <b>varbinary(max)</b>.</p>
      <p xmlns="">Os cenários primários para trabalhar com tipos de valor grande envolvem recuperá-los de um banco de dados ou adicioná-los a um banco de dados. As seções a seguir descrevem abordagens diferentes para realizar estas tarefas.</p>
    </content><sections xmlns="http://ddue.schemas.microsoft.com/authoring/2003/5">
      <h1 class="heading" xmlns="">Recuperando tipos de valor grande de um banco de dados</h1><div id="sectionSection" class="section" xmlns=""><content xmlns="http://ddue.schemas.microsoft.com/authoring/2003/5">
          <p xmlns="">Quando você recuperar um tipo de dados de valor grande não binário — como o tipo de dados <b>varchar(max)</b> — de um banco de dados, uma abordagem é ler esses dados como um fluxo de caracteres. No exemplo seguinte, o método <a href="599cf463-e19f-4baa-bacb-513cad7c6cd8.htm">executeQuery</a> da classe <a href="ec24963c-8b51-4838-91e9-1fbfa2347451.htm">SQLServerStatement</a> é usado para recuperar dados do banco de dados e retorná-los como conjunto de resultados. Em seguida, o método <a href="c70e210f-0288-47cc-9268-a29c45979729.htm">getCharacterStream</a> da classe <a href="eaffcff1-286c-459f-83da-3150778480c9.htm">SQLServerResultSet</a> é usado para ler os dados de valor grande do conjunto de resultados.</p>
          <div class="sampleCode" xmlns=""><span codeLanguage="other"><pre>ResultSet rs = stmt.executeQuery("SELECT TOP 1 * FROM Test1");
rs.next();
Reader reader = rs.getCharacterStream(2);</pre></span></div>
          <div style="margin: .5em 1.5em .5em 1.5em" xmlns=""><b>Observação: </b>
            Esta mesma abordagem também pode ser usada para os tipos de dados <b>text</b>, <b>ntext</b> e <b>nvarchar(max)</b>.<p />
          </div>
          <p xmlns="">Quando você recuperar um tipo de dados de valor grande e binário — como o tipo de dados <b>varbinary(max)</b> — de um banco de dados, existem diversas abordagens que você pode adotar. A abordagem mais eficiente é ler os dados como um fluxo binário, da seguinte maneira:</p>
          <div class="sampleCode" xmlns=""><span codeLanguage="other"><pre>ResultSet rs = stmt.executeQuery("SELECT photo FROM mypics");
rs.next();
InputStream is = rs.getBinaryStream(2);</pre></span></div>
          <p xmlns="">Você também pode usar o método <a href="d16a0aea-6144-4fcb-bcbc-5d7daa36d327.htm">getBytes</a> para ler os dados como uma matriz de bytes, da seguinte maneira:</p>
          <div class="sampleCode" xmlns=""><span codeLanguage="other"><pre>ResultSet rs = stmt.executeQuery("SELECT photo FROM mypics");
rs.next();
byte [] b = rs.getBytes(2);</pre></span></div>
          <div style="margin: .5em 1.5em .5em 1.5em" xmlns=""><b>Observação: </b>
            Você também pode ler os dados como um BLOB. Porém, isto é menos eficiente que os dois métodos mostrados previamente.<p />
          </div>
        </content></div>
      <h1 class="heading" xmlns="">Adicionando tipos de valor grande a um banco de dados</h1><div id="sectionSection" class="section" xmlns=""><content xmlns="http://ddue.schemas.microsoft.com/authoring/2003/5">
          <p xmlns="">Carregar dados grandes com o driver JDBC funciona bem para os casos dimensionados por memória; nos casos maiores que a memória, streaming é a opção primária. Porém, o modo mais eficiente de carregar dados grandes é pelas interfaces de fluxo.</p>
          <p xmlns="">Usar uma cadeia de caracteres ou bytes também é uma opção, da seguinte maneira:</p>
          <div class="sampleCode" xmlns=""><span codeLanguage="other"><pre>PreparedStatement pstmt = con.prepareStatement("INSERT INTO test1 (c1_id, c2_vcmax) VALUES (?, ?)");
pstmt.setInt(1, 1);
pstmt.setString(2, htmlStr);
pstmt.executeUpdate();</pre></span></div>
          <div style="margin: .5em 1.5em .5em 1.5em" xmlns=""><b>Observação: </b>
            Esta abordagem também pode ser usada para obter valores que são armazenados nas colunas <b>text</b>, <b>ntext</b> e <b>nvarchar(max)</b>.<p />
          </div>
          <p xmlns="">Se você tiver uma biblioteca de imagem no servidor e precisar carregar arquivos de imagem binários inteiros para uma coluna <b>varbinary(max)</b>, o método mais eficiente com o driver JDBC será usar fluxos diretamente, da seguinte maneira:</p>
          <div class="sampleCode" xmlns=""><span codeLanguage="other"><pre>PreparedStatement pstmt = con.prepareStatement("INSERT INTO test1 (Col1, Col2) VALUES(?,?)");
File inputFile = new File("CLOBFile20mb.jpg");
FileInputStream inStream = new FileInputStream(inputFile);
int id = 1;
pstmt.setInt(1,id);
pstmt.setBinaryStream(2, inStream);
pstmt.executeUpdate();
inStream.close();</pre></span></div>
          <div style="margin: .5em 1.5em .5em 1.5em" xmlns=""><b>Observação: </b>
            Usar o método CLOB ou BLOB não é uma maneira eficiente de carregar dados grandes.<p />
          </div>
        </content></div>
      <h1 class="heading" xmlns="">Modificando tipos de valor grande em um banco de dados</h1><div id="sectionSection" class="section" xmlns=""><content xmlns="http://ddue.schemas.microsoft.com/authoring/2003/5">
          <p xmlns="">Na maioria dos casos, o método indicado para atualizar ou modificar valores grandes no banco de dados é passar parâmetros pelas classes <a href="a8481c06-fbba-432b-8c69-4f4619c20ad4.htm">SQLServerPreparedStatement</a> e <a href="30710a63-c05d-47d9-9cf9-c087a1c76373.htm">SQLServerCallableStatement</a> usando comandos Transact-SQL como UPDATE, WRITE e SUBSTRING.</p>
          <p xmlns="">Se você tiver que substituir a instância de uma palavra em um arquivo de texto grande, como um arquivo HTML, poderá usar um objeto <b>Clob</b>, da seguinte maneira:</p>
          <div class="sampleCode" xmlns=""><span codeLanguage="other"><pre>String SQL = "SELECT * FROM test1;";
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
ResultSet rs = stmt.executeQuery(SQL);
rs.next();

Clob clob = rs.getClob(2);
long pos = clob.position("dog", 1);
clob.setString(pos, "cat");
rs.updateClob(2, clob);
rs.updateRow();</pre></span></div>
          <p xmlns="">Adicionalmente, você pode fazer todo o trabalho no servidor e só passar parâmetros para uma instrução UPDATE preparada.</p>
          <p xmlns="">Para obter mais informações sobre tipos de valor grande, consulte "Usando tipos de valor grande" nos Manuais Online do SQL Server.</p>
        </content></div>
    </sections></div><h1 class="heading">Tipo de dados XML</h1><div id="sectionSection2" class="section"><content xmlns="http://ddue.schemas.microsoft.com/authoring/2003/5">
      <p xmlns="">
        O SQL Server fornece um tipo de dados <b>xml</b> que permite armazenar fragmentos e documentos XML em um banco de dados do SQL Server. O tipo de dados <b>xml</b> é interno no SQL Server e, em alguns aspectos, é semelhante a outros tipos internos, como <b>int</b> e <b>varchar</b>. Assim como em outros tipos internos, você pode usar o tipo de dados <b>xml</b> como um tipo de coluna quando cria uma tabela; como um tipo de variável, de parâmetro ou de retorno de função; ou em funções CAST e CONVERT do Transact-SQL .</p>
      <p xmlns="">No driver JDBC, o tipo de dados <b>xml</b> pode ser mapeado como um objeto de Cadeia de Caracteres, matriz de bytes, fluxo, CLOB, BLOB ou SQLXML. Cadeia de caracteres é o padrão. A partir do JDBC Driver versão 2.0, o driver JDBC dá suporte à API do JDBC 4.0, que apresenta a interface SQLXML. A interface SQLXML define métodos para interagir com dados XML e manipulá-los. O tipo de dados <b>SQLXML</b> mapeia para o tipo de dados <b>xml</b> do SQL Server. Para obter mais informações sobre como ler e escrever dados XML de e para o banco de dados relacional com o tipo de dados <b>SQLXML</b> Java, consulte <a href="32b7217e-1f0c-473d-9a45-176daa81584e.htm">Dando suporte a dados XML</a>.</p>
      <p xmlns="">A implementação do tipo de dados <b>xml</b> no driver JDBC fornece suporte para o seguinte:</p>
      <ul xmlns=""><li>
          Acesso ao XML como uma cadeia de caracteres Java UTF-16 padrão para a maioria dos cenários comuns de programação<br />
        </li><li>
          Entrada de UTF-8 e outros XML codificados de 8 bits<br />
        </li><li>
          Acesso ao XML como uma matriz de byte com um BOM principal quando for codificado em UTF-16 para intercâmbio com outros processadores de XML e arquivos em disco<br />
        </li></ul>
      <p xmlns="">
        O SQL Server exige um BOM principal para XML codificado como UTF-16. O aplicativo deve fornecer isto quando os valores de parâmetro de XML são fornecidos como matrizes de byte. O SQL Server sempre produz valores XML como cadeias de caracteres de UTF-16 sem BOM ou declaração de codificação incorporada. Quando os valores XML são recuperados como byte[], BinaryStream ou Blob, um BOM UTF-16 é pré-demarcado no valor.</p>
      <p xmlns="">Para obter mais informações sobre os tipos de dados <b>xml</b>, veja "Tipo de dados xml" nos Manuais online do SQL Server.</p>
    </content></div><h1 class="heading">Tipo de dados definido pelo usuário</h1><div id="sectionSection3" class="section"><content xmlns="http://ddue.schemas.microsoft.com/authoring/2003/5">
      <p xmlns="">A introdução de tipos definidos pelo usuário (UDTs) no SQL Server 2005 estende o sistema de tipos de SQL, permitindo armazenar objetos e estruturas de dados personalizadas em um banco de dados do SQL Server. Os UDTs podem conter vários tipos de dados e ter comportamentos, o que os diferencia dos tipos de dados de alias tradicionais, que consistem em um único tipo de dado do sistema no SQL Server. As UDTs são definidas por usarem qualquer uma das linguagens para as quais o CLR do Microsoft .NET Framework oferece suporte e que produzem código verificável. Isto inclui Microsoft Visual C# e Visual Basic .NET. Os dados são expostos como campos e propriedades de uma classe ou estrutura baseada no .NET Framework, e os comportamentos são definidos pelos métodos da classe ou estrutura. </p>
      <p xmlns="">No SQL Server, um UDT pode ser usado como definição da coluna de uma tabela, como uma variável em um lote do Transact-SQL ou como um argumento de uma função Transact-SQL ou procedimento armazenado.</p>
      <p xmlns="">Para obter mais informações sobre tipos de dados definidos pelo usuário, consulte "Usando e modificando instâncias de tipos definidos pelo usuário" nos Manuais online do SQL Server.</p>
    </content></div><span id="seeAlsoSpan"><h1 class="heading">Consulte também</h1></span><div id="seeAlsoSection" class="section" name="collapseableSection"><a href="7802328d-4d23-4775-9573-4169b127d258.htm">Entendendo os tipos de dados do JDBC Driver</a><br /><br /></div><!--[if gte IE 5]>
			<tool:tip element="seeAlsoToolTip" avoidmouse="false"/><tool:tip element="languageFilterToolTip" avoidmouse="false"/><tool:tip element="roleInfoSpan" avoidmouse="false"/>
		<![endif]-->
      <div id="footer" class="section">
        
		<hr />
		
		<span id="fb" class="feedbackcss">
			
			
		</span>
		
		<a href="9bad553b-9e70-4696-8499-2e35f772a1e0.htm">
			
			© 2010 Microsoft Corporation. Todos os direitos reservados.
		</a>
 	
	
      </div>
    </div>
  </body>
</html>